home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / DESKTOP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-04  |  33.8 KB  |  1,319 lines
  1. #include "global.h"
  2. #include "av.h"
  3. #include "clipbrd.h"
  4. #include "disk.h"
  5. #include "edit.h"
  6. #include "file.h"
  7. #include "icon.h"
  8. #include "makro.h"
  9. #include "menu.h"
  10. #include "obj.h"
  11. #include "options.h"
  12. #include "rsc.h"
  13. #include "set.h"
  14. #include "text.h"
  15. #include "version.h"
  16. #include "windows.h"
  17. #include "desktop.h"
  18.  
  19. #define KIND    (NAME|CLOSER|FULLER|MOVER|SIZER|UPARROW|DNARROW|VSLIDE|LFARROW|RTARROW|HSLIDE)
  20. #define KIND2    (NAME|CLOSER|MOVER)
  21. #define FLAGS    (WI_NONE)
  22. #define XFAC    sys_wchar                /* X-Faktor */
  23. #define YFAC    sys_hchar                /* Y-Faktor */
  24. #define INITX    (2 * sys_wchar)                /* X-Anfangsposition */
  25. #define INITY    (6 * sys_hchar)                /* Y-Anfangsposition */
  26. #define INITW    (desk.x + desk.w -  6*sys_wchar)    /* Anfangsbreite in Pixel */
  27. #define INITH    (desk.y + desk.h - 10*sys_hchar)    /* Anfangshöhe in Pixel */
  28.  
  29. #define ICON_RASTER_X    (icons[IDISK].ob_width+2)
  30. #define ICON_RASTER_Y    (icons[IDISK].ob_height+2)
  31.  
  32. /* lokale Variablen ********************************************************/
  33.  
  34. LOCAL BOOLEAN        killed = FALSE, destruct = FALSE;;
  35. LOCAL SET            used_icons;
  36.  
  37. /* lokale Prototypen *******************************************************/
  38.  
  39. LOCAL VOID         draw_winobject (WINDP window, WORD obj);
  40. LOCAL VOID         draw_box            (CONST RECT *box, WORD x_offset, WORD y_offset);
  41. LOCAL VOID         draw_all            (WORD num_boxes, CONST RECT *boxes, WORD x_offset, WORD y_offset);
  42. LOCAL VOID         check_drag        (WORD x_offset, WORD y_offset, CONST RECT *bound, CONST RECT *inner, RECT *diff);
  43. LOCAL BOOLEAN    drag_react        (WORD src_obj, WORD dest_obj);
  44. LOCAL VOID        drag_objs        (WINDP window, SET objs, WORD m_x, WORD m_y);
  45. LOCAL VOID        get_selected    (WINDP window, SET objs, RECT *area);
  46. LOCAL VOID        select_objs        (WINDP window, SET objs);
  47. LOCAL VOID        clear_objs        (WINDP window, SET objs);
  48. LOCAL VOID        invert_objs     (WINDP window, SET objs);
  49. LOCAL VOID        rubber_objs     (WINDP window, MKINFO *mk);
  50. LOCAL BOOLEAN    in_icon            (WORD mox, WORD moy, OBJECT *dialog, WORD obj);
  51.  
  52. LOCAL VOID         wi_draw            (WINDP window, CONST RECT *r);
  53. LOCAL VOID        wi_click            (WINDP window, MKINFO *mk);
  54. LOCAL VOID        wi_unclick        (WINDP window);
  55. LOCAL BOOLEAN    wi_key            (WINDP window, MKINFO *mk);
  56.  
  57. LOCAL BOOLEAN    check_end        (WORD action);
  58. LOCAL VOID        icon_exist        (WORD icon, SET actions);
  59. LOCAL BOOLEAN    icon_test        (WORD icon, WORD action);
  60. LOCAL WORD        icon_edit        (WORD icon, WORD action);
  61. LOCAL VOID        crt_desktop     (WORD icon, WINDP window);
  62. LOCAL BOOLEAN    open_desktop    (VOID);
  63.  
  64. /***************************************************************************/
  65.  
  66. LOCAL BOOLEAN check_end(WORD action)
  67. {
  68.     WORD    anz, i;
  69.     WORD    ic, icp[MAX_ICON_ANZ];
  70.     SET    actions;
  71.  
  72.     if (action==DO_DESTRUCT && makro_rec)
  73.         return FALSE;
  74.     anz = all_icons(icp);
  75.  
  76.     /* Erst alle testen, dann alle killen */
  77.     i = anz;
  78.     while ((--i)>=0)
  79.     {
  80.         ic = icp[i];
  81.         if (ic!=0)
  82.         {
  83.             Icon_exist(ic,actions);
  84.             if (setin(actions,action))
  85.                 if (!Icon_test(ic,action))
  86.                     return FALSE;
  87.         }
  88.     }
  89.     if (makro_rec)
  90.         end_rec(FALSE);
  91.     if (action==DO_DESTRUCT && (save_opt==0)!=(global_shift==0))
  92.         option_save(FALSE);
  93.     i = anz;
  94.     if (action==DO_DESTRUCT)
  95.         destruct = TRUE;
  96.     while ((--i)>=0)
  97.     {
  98.         ic = icp[i];
  99.         if (ic!=0)
  100.         {
  101.             Icon_exist(ic,actions);
  102.             if (setin(actions,action))
  103.                 Icon_edit(ic,action);
  104.         }
  105.     }
  106.     destruct = FALSE;
  107.     return TRUE;
  108. }
  109.  
  110. /***************************************************************************/
  111. /* Operation vorhanden ?                                                                    */
  112. /***************************************************************************/
  113.  
  114. LOCAL VOID icon_exist(WORD icon, SET actions)
  115. {
  116.     setclr(actions);
  117.     setincl(actions,DO_DESTRUCT);
  118.     setincl(actions,DO_OPEN);
  119.     setincl(actions,DO_HELP);
  120.     setincl(actions,DO_INFO);
  121.     setincl(actions,DO_FIND);
  122.     if (!no_desktop)
  123.         setincl(actions,DO_SELALL);
  124. }
  125.  
  126. /***************************************************************************/
  127. /* Operation testen                                                                            */
  128. /***************************************************************************/
  129.  
  130. LOCAL BOOLEAN icon_test(WORD icon, WORD action)
  131. {
  132.     BOOLEAN erg;
  133.  
  134.     switch(action)
  135.     {
  136.         case DO_DESTRUCT:
  137.             if (killed)            /* Wird bei AC_CLOSE aufgerufen */
  138.                 erg = TRUE;
  139.             else
  140.                 erg = check_end(DO_DESTRUCT);
  141.             break;
  142.         case DO_OPEN    :
  143.             if (killed && (long)Malloc(-1L) < 55000L)
  144.             {
  145.                 note(1,NOMEMORY);
  146.                 erg = FALSE;
  147.             }
  148.             else
  149.                 erg = TRUE;
  150.             break;
  151.         case DO_INFO    :
  152.             erg = TRUE;
  153.             break;
  154.         case DO_SELALL    :
  155.             erg = (!no_desktop);
  156.             break;
  157.         case DO_FIND    :
  158.             erg = Icon_test(idisk, DO_FIND);
  159.             break;
  160.         case DO_HELP    :
  161.             erg = TRUE;    break;
  162.         default:
  163.             erg = FALSE;
  164.     }
  165.     return erg;
  166. }
  167.  
  168. /***************************************************************************/
  169. /* Operation durchführen                                                                    */
  170. /***************************************************************************/
  171.  
  172. LOCAL WORD icon_edit(WORD icon, WORD action)
  173. {
  174.     WORD    erg = 1;
  175.     WINDP    window;
  176.  
  177.     window = get_window (0);
  178.     switch(action)
  179.     {
  180.         case DO_CLOSE    :
  181.             if (window->opened)
  182.                 close_window(window);
  183.             done = TRUE;
  184.             break;
  185.         case DO_DESTRUCT:
  186.             if (!killed)    /* Wird bei AC_CLOSE aufgerufen */
  187.             {
  188.                 if (window->opened)
  189.                     close_window(window);
  190.                 kill_memory();
  191.                 killed = TRUE;
  192.                 done = TRUE;
  193.             }
  194.             break;
  195.         case DO_OPEN    :
  196.             if (killed)
  197.             {
  198.                 do_all_icon(ALL_TYPES,DO_REINIT);
  199.                 killed = FALSE;
  200.             }
  201.             if (!open_desktop())
  202.                 erg = -1;
  203.             break;
  204.         case DO_SELALL    :
  205.             if (window!=sel_window)
  206.                 unclick_window();
  207.             select_objs(window,used_icons);
  208.             setcpy(sel_objs,used_icons);
  209.             sel_window = setcmp (sel_objs, NULL) ? NULL : window;
  210.             break;
  211.         case DO_INFO    :
  212.             info_desktop();
  213.             erg = TRUE;
  214.             break;
  215.         case DO_FIND    :
  216.             erg = Icon_edit(idisk, DO_FIND);
  217.             break;
  218.         case DO_HELP    :
  219.             erg = call_hyp("main");
  220.             break;
  221.     }
  222.     return erg;
  223. }
  224.  
  225. /***************************************************************************/
  226.  
  227. LOCAL VOID draw_box (CONST RECT *box, WORD x_offset, WORD y_offset)
  228. {
  229.     WORD xy[10];
  230.     WORD m1, m2;
  231.  
  232.     xy[2] = xy[0] = x_offset + box->x;        /* Dieser Teil ist RICHTIG !!! */
  233.     xy[7] = xy[1] = y_offset + box->y;
  234.     xy[3] = xy[1] + box->h-1;
  235.     xy[4] = xy[0] + box->w-1;
  236.     *(long*)(xy+5) = *(long*)(xy+3);
  237.     *(long*)(xy+8) = *(long*)(xy+0);            /* Punkt 0 ist gleich Punkt 5 */
  238.  
  239.     m1 = 0xAAAA; m2 = 0x5555;
  240.     vsl_udsty (vdi_handle, odd (xy[0]+xy[1]) ? m1 : m2);
  241.     v_pline (vdi_handle, 2, &xy[0]);
  242.     vsl_udsty (vdi_handle, odd (xy[3]) ? m1 : m2);
  243.     v_pline (vdi_handle, 2, &xy[2]);
  244.     vsl_udsty (vdi_handle, odd (xy[4]+xy[5]) ? m1 : m2);
  245.     v_pline (vdi_handle, 2, &xy[4]);
  246.     vsl_udsty (vdi_handle, odd (xy[7]) ? m1 : m2);
  247.     v_pline (vdi_handle, 2, &xy[6]);
  248. } /* draw_box */
  249.  
  250. /***************************************************************************/
  251.  
  252. LOCAL VOID draw_all (WORD num_boxes, CONST RECT *boxes, WORD x_offset, WORD y_offset)
  253. {
  254.     WORD i;
  255.  
  256.     Hide_mouse ();
  257.     set_clip (TRUE, &desk);
  258.     for (i = num_boxes; (--i)>=0 ; )
  259.         draw_box (boxes++, x_offset, y_offset);
  260.     Show_mouse ();
  261. } /* draw_all */
  262.  
  263. /***************************************************************************/
  264.  
  265. LOCAL VOID draw_winobject (WINDP window, WORD obj)
  266. {
  267.     WORD    wh, start_obj;
  268.     RECT    r1, r2;
  269.  
  270.     if (window!=NULL && window->opened && desktop != NULL)
  271.     {
  272.         wh = window->handle;
  273.  
  274.         if (get_obtype(desktop, obj, NULL) == G_CICON)
  275.         {
  276.             /*
  277.              * Bei den Icons (z.B. Tonne) mu₧ wegen der unterschiedlichen Grö₧e
  278.              * der Hintergrund auch neu gezeichnet werden. Daher wird das ROOT-
  279.              * Objekt mit Clipping auf das Icon gemalt!
  280.             */
  281.             objc_offset(desktop, obj, &r2.x, &r2.y);
  282.             r2.w = desktop[obj].ob_width;
  283.             r2.h = desktop[obj].ob_height;
  284.             start_obj = ROOT;
  285.         }
  286.         else
  287.         {
  288.             objc_rect (desktop, obj, &r2, FALSE);
  289.             start_obj = obj;
  290.         }
  291.         if (myrc_intersect (&window->work, &r2))
  292.         {
  293.             if (rc_first(wh, &r2, &r1))
  294.                 do
  295.                 {
  296.                     objc_draw (desktop, start_obj, MAX_DEPTH, r1.x, r1.y, r1.w, r1.h);
  297.                 }
  298.                 while (rc_next(wh, &r1));
  299.         }
  300.     }
  301. } /* draw_object */
  302.  
  303. /***************************************************************************/
  304.  
  305. LOCAL VOID check_drag(WORD x_offset, WORD y_offset, CONST RECT *bound, CONST RECT *inner, RECT *diff)
  306. {
  307.     WORD i, delta;
  308.  
  309.     delta = 0;
  310.     i = bound->x-(inner->x+x_offset);
  311.     if (i > 0) delta = i;                                    /* Links heraushängend */
  312.     i = bound->x+bound->w-(inner->x+inner->w+x_offset);
  313.     if (i < 0)                                                    /* Rechts heraushängend */
  314.     {
  315.         if (delta)
  316.             delta = -x_offset;                                /* Keine Verschiebung */
  317.         else
  318.             delta = i;
  319.     }
  320.     x_offset += delta;
  321.  
  322.     delta = 0;
  323.     i = bound->y - (inner->y+y_offset);
  324.     if (i > 0) delta = i;                                    /* Oben heraushängend */
  325.     i = bound->y + bound->h - (inner->y + inner->h + y_offset);
  326.     if (i < 0)                                                    /* Unten heraushängend */
  327.     {
  328.         if (delta)
  329.             delta = -y_offset;
  330.         else
  331.             delta = i;
  332.     }
  333.     y_offset += delta;
  334.  
  335.     diff->w = x_offset;
  336.     diff->h = y_offset;
  337. }
  338.  
  339. LOCAL VOID drag_boxes (WORD num_objs, CONST RECT *boxes, WINDP window, SET inv_objs,
  340.                              RECT *diff, const RECT *bound, MKINFO *rmk)
  341. {
  342.     WORD        event, i, obj, last_obj, kreturn;
  343.     WORD        x_mstart, y_mstart;        /* MausPos ganz am Anfang */
  344.     RECT        inner;                        /* Box über alle Icons */
  345.     MKINFO    mk;
  346.     OBJECT    *object;
  347.     CONST RECT *ptr;
  348.  
  349.     x_mstart = mk.mox = diff->x;
  350.     y_mstart = mk.moy = diff->y;
  351.  
  352.     inner.x = 0; inner.y = 0; inner.w = 0; inner.h = 0;
  353.     ptr = boxes;
  354.     for (i = num_objs; (--i)>=0; )                        /* Vereinigungsbox */
  355.         myrc_union (ptr++, &inner);
  356.  
  357.     diff->w  = diff->h  = 0;
  358.     obj        = last_obj = NIL;
  359.     object    = NULL;
  360.  
  361.     if (window != NULL) object = desktop;
  362.     if (bound == NULL) bound = &desk;
  363.  
  364.     vswr_mode (vdi_handle, MD_XOR);                        /* Modi einstellen */
  365.     vsl_type (vdi_handle, USERLINE);
  366.  
  367.     draw_all (num_objs, boxes, diff->w, diff->h);
  368.     do
  369.     {
  370.         event = evnt_multi ( MU_BUTTON | MU_M1,
  371.                                     1, 0x01, 0x00,
  372.                                     TRUE, mk.mox, mk.moy, 1, 1,
  373.                                     0, 0, 0, 0, 0,
  374.                                     NULL,
  375.                                     0, 0,
  376.                                     &mk.mox, &mk.moy,
  377.                                     &mk.mobutton, &mk.kstate,
  378.                                     &kreturn, &mk.breturn);
  379.  
  380.         if (event==MU_M1)        /* wenn MU_BUTTON dann hier nicht mehr rein */
  381.         {
  382.             draw_all (num_objs, boxes, diff->w, diff->h);
  383.             if (object != NULL)
  384.             {
  385.                 last_obj = obj;
  386.                 if (wind_find(mk.mox, mk.moy)==window->handle &&
  387.                      inside(mk.mox,mk.moy,&window->work))
  388.                     obj = objc_find (object, ROOT, MAX_DEPTH, mk.mox, mk.moy);
  389.                 else
  390.                     obj = NIL;
  391.                 if (obj!=last_obj)
  392.                 {
  393.                     if (setin (inv_objs, last_obj))
  394.                     {
  395.                         select_objc(object, last_obj, FALSE);
  396.                         draw_winobject (window, last_obj);
  397.                     }
  398.                     if (setin (inv_objs, obj))
  399.                     {
  400.                         select_objc(object, obj, TRUE);
  401.                         draw_winobject (window, obj);
  402.                     }
  403.                 }
  404.             }
  405.             check_drag(mk.mox-x_mstart, mk.moy-y_mstart, bound, &inner, diff);
  406.             diff->x = mk.mox;
  407.             diff->y = mk.moy;
  408.             draw_all (num_objs, boxes, diff->w, diff->h);
  409.         }
  410.     }while (!(event&MU_BUTTON));
  411.     draw_all (num_objs, boxes, diff->w, diff->h);
  412.  
  413.     if (setin (inv_objs, obj))                            /* Wieder normal darstellen */
  414.     {
  415.         select_objc(object, obj, FALSE);
  416.         draw_winobject (window, obj);
  417.     }
  418.  
  419.     vsl_type (vdi_handle, SOLID);
  420.     vswr_mode (vdi_handle, MD_REPLACE);                /* Modi zurücksetzen */
  421.     if (rmk != NULL)
  422.         memcpy(rmk, &mk, sizeof(MKINFO));
  423. } /* drag_boxes */
  424.  
  425. /***************************************************************************/
  426.  
  427. VOID set_fkey(WORD scan, CONST UBYTE *str)
  428. {
  429.     WORD    obj;
  430.  
  431.     if ((scan >= 0x3B00) && (scan <= 0x4400))        /* F1 - F10 */
  432.         obj =((scan - 0x3B00) / 0x100) + IF1;
  433.     else if ((scan >= 0x5400) && (scan <= 0x5D00))        /* F11 - F20 */
  434.         obj =((scan - 0x5400) / 0x100) + IFS1;
  435.     objc_setstring (desktop, obj, (BYTE*) str);
  436. }
  437.  
  438. VOID draw_fkey (WORD scan, BOOLEAN selected)
  439. {
  440.     WORD    obj;
  441.  
  442.     if ((scan >= 0x3B00) && (scan <= 0x4400))        /* F1 - F10 */
  443.         obj =((scan - 0x3B00) / 0x100) + IF1;
  444.     else if ((scan >= 0x5400) && (scan <= 0x5D00))        /* F11 - F20 */
  445.         obj =((scan - 0x5400) / 0x100) + IFS1;
  446.     select_objc(desktop, obj, selected);
  447.     draw_winobject(get_window (0), obj);
  448. }
  449.  
  450. /***************************************************************************/
  451. /* Diese Procedur wird bei Verschiebungen von Icons auf dem Desktop            */
  452. /* aufgerufen. (Aufruf von Routine für Ziel--Icon)                                    */
  453. /***************************************************************************/
  454.  
  455. LOCAL BOOLEAN drag_react (WORD src_obj, WORD dest_obj)
  456. {
  457.     return Icon_drag(dest_obj,src_obj);
  458. } /* drag_react */
  459.  
  460. /***************************************************************************/
  461.  
  462. WORD drag_to_desktop(const RECT r[], WORD anz, WORD m_x, WORD m_y,
  463.                             BOOLEAN *mywin, MKINFO *mk)
  464. {
  465.     RECT    diff;
  466.     WINDP    dest_window;
  467.     WORD    dest_obj, dest_hdl;
  468.  
  469.     diff.x = m_x;
  470.     diff.y = m_y;
  471.     Set_mouse (FLAT_HAND);
  472.     drag_boxes (anz, r, get_window(0), used_icons, &diff, &desk, mk);
  473.     Last_mouse ();
  474.     m_x = diff.x;
  475.     m_y = diff.y;
  476.     dest_hdl = wind_find(m_x, m_y);
  477.     dest_window = find_window (dest_hdl);
  478.     if (dest_window != NULL)
  479.     {
  480.         *mywin = TRUE;
  481.         if (dest_window->class == DESK)
  482.         {
  483.             dest_obj = objc_find (desktop, ROOT, MAX_DEPTH, m_x, m_y);
  484.             if (dest_obj>0 && setin(used_icons,dest_obj))
  485.                 return dest_obj;
  486.             else
  487.                 return ROOT;
  488.         }
  489.         else
  490.             return dest_window->link;
  491.     }
  492.     else if (dest_hdl >= 0)                /* D&D zu anderem Programm */
  493.     {
  494.         *mywin = FALSE;
  495.         return dest_hdl;
  496.     }
  497.     return -1;
  498. }
  499.  
  500. /***************************************************************************/
  501.  
  502. LOCAL VOID drag_objs (WINDP window, SET objs, WORD m_x, WORD m_y)
  503. {
  504.     RECT        ob, newob, diff;
  505.     WORD        i, max, num_objs, result, mobutton, kstate;
  506.     WORD        dest_obj;
  507.     WINDP        dest_window;
  508.     SET        inv_objs, help;
  509.     BOOLEAN    action;
  510.     RECT        all[MAX_ICON_ANZ];
  511.  
  512.     graf_mkstate (&result, &result, &mobutton, &kstate);
  513.     global_shift = (kstate & 3);
  514.  
  515.     if (!(mobutton&1))
  516.         return;                            /* Immernoch gedrückt ?    */
  517.  
  518.     max = setmax(objs);
  519.     for (i=setmin(objs), num_objs=0; i<=max; i++)
  520.     {
  521.         if (setin (objs, i))                /* ist invertiert */
  522.             objc_rect (desktop, i, &all[num_objs++], FALSE);
  523.     }
  524.  
  525.     if (setin(objs,FKEYS))
  526.     {
  527.         setclr(inv_objs);
  528.     }
  529.     else
  530.     {
  531.         setcpy (inv_objs, used_icons);
  532.         setcpy (help, objs);
  533.         setnot (help);
  534.         setand (inv_objs, help);            /* nicht sel. Objekte = inv_objs */
  535.     }
  536.  
  537.     diff.x = m_x;
  538.     diff.y = m_y;
  539.     Set_mouse (FLAT_HAND);
  540.     drag_boxes (num_objs, all, window, inv_objs, &diff, &desk, NULL);
  541.     Last_mouse ();
  542.     m_x = diff.x;
  543.     m_y = diff.y;
  544.  
  545.     action = FALSE;
  546.     dest_window = find_window (wind_find (m_x, m_y));
  547.     if (dest_window != NULL && dest_window->class == DESK)
  548.     {
  549.         /* Auf Desktop verschoben */
  550.         dest_obj = objc_find (desktop, ROOT, 1, m_x, m_y);
  551.         if (dest_obj==-1 || setin(objs,dest_obj) || dest_obj==ROOT || setin(objs,FKEYS))
  552.         /* Icons auf Desktop verschieben */
  553.         {
  554.             for (i=0, num_objs=0; i<=max; i++) if (setin (objs, i))
  555.             {
  556.                 move_icon(i,diff.w,diff.h);
  557.             }
  558.         }
  559.         else        /* Icon auf Icon : Aktion durchführen */
  560.         {
  561.             objc_rect (desktop, dest_obj, &newob, FALSE);
  562.             for (i=0, num_objs=0; i<=max; i++) if (setin (objs, i))
  563.             {
  564.                 if (!drag_react(i, dest_obj))
  565.                 {
  566.                     ob = all[num_objs];
  567.                     newob.w = ob.w;
  568.                     newob.h = ob.h;
  569.                     graf_movebox (newob.w, newob.h, newob.x, newob.y, ob.x, ob.y);
  570.                 }
  571.                 else
  572.                     action = TRUE;
  573.                 num_objs++;
  574.             }
  575.         }
  576.     }
  577.     else        /* Icon auf Fenster : Aktion durchführen */
  578.     {
  579.         if (dest_window!=NULL)
  580.             dest_obj = dest_window->link;
  581.         else
  582.             dest_obj = -1;
  583.         for (i=0, num_objs=0; i<=max; i++) if (setin (objs, i))
  584.         {
  585.             if (!drag_react(i, dest_obj))
  586.             {
  587.                 ob = all[num_objs];
  588.                 ob.x += diff.w;
  589.                 ob.y += diff.h;
  590.                 graf_movebox (ob.w, ob.h, ob.x, ob.y, -diff.w, -diff.h);
  591.             }
  592.             else
  593.                 action = TRUE;
  594.             num_objs++;
  595.         }
  596.     }
  597.     if (action)                                /* Nach Aktion deselektieren */
  598.         unclick_window ();
  599. } /* drag_objs */
  600.  
  601. /***************************************************************************/
  602.  
  603. LOCAL VOID get_selected (WINDP window, SET objs, RECT *area)
  604. {
  605.     WORD        i;
  606.     RECT        r;
  607.     OBJECT    *object = desktop;
  608.  
  609.     setclr (objs);
  610.     for (i=setmax(used_icons); i>=0; i--)
  611.         if (setin(used_icons,i))
  612.         {
  613.             objc_rect (object, i, &r, FALSE);
  614.             if (myrc_intersect(area, &r) && myrc_intersect(&window->work, &r))
  615.                 setincl (objs, i);
  616.         }
  617. } /* get_selected */
  618.  
  619. /***************************************************************************/
  620.  
  621. LOCAL VOID select_objs (WINDP window, SET objs)
  622. {
  623.     WORD i;
  624.     OBJECT *object;
  625.  
  626.     i = setmax(objs);
  627.     for (object=&desktop[i]; i>=0; i--,object--)
  628.         if (setin (objs, i) && i!=FKEYS)
  629.         {
  630.             object->ob_state |= SELECTED;
  631.             draw_winobject (window, i);
  632.         }
  633. } /* select_objs */
  634.  
  635. /***************************************************************************/
  636.  
  637. LOCAL VOID clear_objs (WINDP window, SET objs)
  638. {
  639.     WORD i;
  640.     OBJECT *object;
  641.  
  642.     i = setmax(objs);
  643.     for (object=&desktop[i]; i>=0; i--,object--)
  644.         if (setin (objs, i) && i!=FKEYS)
  645.         {
  646.             object->ob_state &= (~SELECTED);
  647.             draw_winobject (window, i);
  648.         }
  649. } /* clear_objs */
  650.  
  651. /***************************************************************************/
  652.  
  653. LOCAL VOID invert_objs (WINDP window, SET objs)
  654. {
  655.     WORD i;
  656.     OBJECT *object;
  657.  
  658.     i = setmax(objs);
  659.     for (object=&desktop[i]; i>=0; i--,object--)
  660.         if (setin (objs, i) && i!=FKEYS)
  661.         {
  662.             object->ob_state ^= SELECTED;
  663.             draw_winobject (window, i);
  664.         }
  665. } /* invert_objs */
  666.  
  667. /***************************************************************************/
  668.  
  669. LOCAL VOID rubber_objs (WINDP window, MKINFO *mk)
  670. {
  671.     WORD    kstate, mobutton;
  672.     RECT    r;
  673.     SET    new_objs;
  674.  
  675.     graf_mkstate (&r.x, &r.y, &mobutton, &kstate);
  676.     if (!(mobutton&1)) return;                        /* Immernoch gedrückt ? */
  677.  
  678.     r.x = mk->mox;
  679.     r.y = mk->moy;
  680.  
  681.     Set_mouse (POINT_HAND);
  682.     graf_rubbox (r.x, r.y, -r.x, -r.y, &r.w, &r.h);
  683.     Last_mouse ();
  684.  
  685.     if (r.w < 0)
  686.     {
  687.         r.x += r.w;
  688.         r.w    = - r.w;
  689.     }
  690.     if (r.h < 0)
  691.     {
  692.         r.y += r.h;
  693.         r.h    = - r.h;
  694.     }
  695.  
  696.     if (kstate & (K_RSHIFT|K_LSHIFT))        /* xor auswählen */
  697.     {
  698.         get_selected (window, new_objs, &r);
  699.         invert_objs (window, new_objs);
  700.         setxor (sel_objs, new_objs);
  701.     }
  702.     else                                                /* Auswählen */
  703.     {
  704.         get_selected (window, sel_objs, &r);
  705.         select_objs (window, sel_objs);
  706.     }
  707.  
  708.     sel_window = setcmp (sel_objs, NULL) ? NULL : window;
  709. } /* rubber_objs */
  710.  
  711. /***************************************************************************/
  712.  
  713. LOCAL BOOLEAN    in_icon (WORD mox, WORD moy, OBJECT *tree, WORD obj)
  714. {
  715.     BOOLEAN    ok;
  716.     CICONBLK    *cicon;
  717.     RECT        r, r1;
  718.  
  719.     ok = FALSE;
  720.     objc_rect(tree, obj, &r, FALSE);
  721.     if (inside (mox, moy, &r))                /* Im gesamten Rechteck */
  722.     {
  723.         cicon = (CICONBLK *)get_obspec(tree, obj);
  724.         r1.x = r.x + cicon->monoblk.ib_xicon;
  725.         r1.y = r.y + cicon->monoblk.ib_yicon;
  726.         r1.w = cicon->monoblk.ib_wicon;
  727.         r1.h = cicon->monoblk.ib_ytext;    /* Bis zum Text, falls Icon kürzer */
  728.         ok = inside (mox, moy, &r1);        /* Im Icon */
  729.         if (! ok)                                /* Vielleicht im Text */
  730.         {
  731.             r1.x = r.x + cicon->monoblk.ib_xtext;
  732.             r1.y = r.y + cicon->monoblk.ib_ytext;
  733.             r1.w = cicon->monoblk.ib_wtext;
  734.             r1.h = cicon->monoblk.ib_htext;
  735.             ok = inside (mox, moy, &r1);    /* Im Text */
  736.         }
  737.     }
  738.     return (ok);
  739. } /* in_icon */
  740.  
  741. /***************************************************************************/
  742.  
  743. BOOLEAN is_icon_on_desk(WORD icon)
  744. {
  745.     return (setin(used_icons,icon));
  746. }
  747.  
  748. /***************************************************************************/
  749. /* Hinzufügen eines Icons zum Desktop                                                    */
  750. /***************************************************************************/
  751.  
  752. WORD add_icon_to_desk(WORD obj, UBYTE *text, WORD x, WORD y)
  753. {
  754.     CICONBLK *cicon1, *cicon2;
  755.     UBYTE        *str;
  756.     WORD        i;
  757.  
  758.     if (obj==0)
  759.     {
  760.         if (x<desk.x)
  761.             x = desk.x;
  762.         if (y<desk.y)
  763.             y = desk.y;
  764.         if (x+desktop[FKEYS].ob_width>desk.x+desk.w)
  765.             x = desk.x+desk.w-desktop[FKEYS].ob_width;
  766.         if (y+desktop[FKEYS].ob_height>desk.y+desk.h)
  767.             y = desk.y+desk.h-desktop[FKEYS].ob_height;
  768.         desktop[FKEYS].ob_x = x;
  769.         desktop[FKEYS].ob_y = y;
  770.         return 0;
  771.     }
  772.     for (i = icon_anzahl; (--i) >= 0; )
  773.     {
  774.         if (!setin(used_icons, i + FIRSTICON))
  775.             break;
  776.     }
  777.     if (i<0)
  778.         return -1;
  779.     i += FIRSTICON;
  780.     setincl(used_icons,i);
  781.  
  782.     cicon1 = (CICONBLK *)get_obspec(desktop, i);
  783.     str = cicon1->monoblk.ib_ptext;
  784.     cicon2 = (CICONBLK *)get_obspec(icons, obj);
  785.     memcpy(cicon1, cicon2, sizeof(CICONBLK));
  786.     cicon1->monoblk.ib_ptext = str;
  787.     if (strlen(text) < 13)
  788.         strcpy(str, text);
  789.     else
  790.         strncpy(str, text, 12);
  791.     desktop[i].ob_x = -1;
  792.     desktop[i].ob_y = -1;
  793.     desktop[i].ob_width = icons[obj].ob_width;
  794.     desktop[i].ob_height = icons[obj].ob_height;
  795.     move_icon_to(i,x,y);
  796.     select_objc(desktop,i,FALSE);
  797.     return i;
  798. }
  799.  
  800. /***************************************************************************/
  801.  
  802. VOID show_icon(WORD icon)
  803. {
  804.     hide_objc(desktop, icon, FALSE);
  805.     draw_winobject(get_window(0), icon);
  806. }
  807.  
  808. /***************************************************************************/
  809.  
  810. VOID move_icon_to(WORD icon, WORD new_x, WORD new_y)
  811. /* Postition relativ zum Desktop (0,0) (nicht zum Bildschirm (0,0)) */
  812. {
  813.     WINDP        window;
  814.     OBJECT    *obj;
  815.     RECT        r, r2, r3;
  816.     WORD        i, anz_x, anz_y;
  817.  
  818.     anz_x = anz_y = 0;
  819. redo:
  820.     obj = desktop+icon;
  821.     if (new_x<0)
  822.         new_x = 0;
  823.     else if (new_x+obj->ob_width>desktop[0].ob_width)
  824.         new_x = desktop[0].ob_width-obj->ob_width;
  825.     if (new_y<desk.y)
  826.         new_y = desk.y;
  827.     else if (new_y+obj->ob_height>desktop[0].ob_height)
  828.         new_y = desktop[0].ob_height-obj->ob_height;
  829.  
  830.     if (icon!=FKEYS)    /* keine zwei Icons auf der gleichen Position */
  831.     {
  832.         for (i=setmax(used_icons); i>=0; i--)
  833.             if (setin(used_icons,i) && (i!=icon))
  834.             {
  835.                 objc_rect (desktop, FKEYS, &r2, FALSE);
  836.                 objc_rect (desktop, i, &r, FALSE);
  837.                 r3.x = new_x;
  838.                 r3.y = new_y;
  839.                 r3.w = ICON_RASTER_X;
  840.                 r3.h = ICON_RASTER_Y;
  841.                 if ((r.x==new_x && r.y==new_y) || myrc_intersect(&r2,&r3))
  842.                 {
  843.                     if (anz_x<=anz_y)
  844.                     {
  845.                         anz_x++;
  846.                         if (new_x>(desktop[0].ob_width>>1))        /* linke Hälft */
  847.                             new_x -= ICON_RASTER_X;
  848.                         else
  849.                             new_x += ICON_RASTER_X;
  850.                     }
  851.                     else
  852.                     {
  853.                         anz_y++;
  854.                         if (new_y>(desktop[0].ob_height>>1))    /* unter Hälfte */
  855.                             new_y -= ICON_RASTER_Y;
  856.                         else
  857.                             new_y += ICON_RASTER_Y;
  858.                     }
  859.                     if (anz_x==10) break;
  860.                     goto redo;
  861.                 }
  862.             }
  863.     }
  864.     if (obj->ob_x!=new_x || obj->ob_y!=new_y)
  865.     {
  866.         objc_rect (desktop, icon, &r, FALSE);
  867.         obj->ob_x = new_x;
  868.         obj->ob_y = new_y;
  869.         if (!(obj->ob_flags & HIDETREE))
  870.         {
  871.             hide_objc(desktop, icon, TRUE);
  872.             window = get_window(0);
  873.             redraw_window (window, &r);
  874.             hide_objc(desktop, icon, FALSE);
  875.             draw_winobject (window, icon);
  876.         }
  877.     }
  878.     window = get_window(icon);                /* immer, weil vielleicht neu */
  879.     if (window!=NULL)
  880.     {
  881.         window->icon_x = obj->ob_x;
  882.         window->icon_y = obj->ob_y;
  883.     }
  884. }
  885.  
  886. /***************************************************************************/
  887.  
  888. VOID move_icon(WORD icon, WORD diff_x, WORD diff_y)
  889. {
  890.     if (diff_x||diff_y)
  891.     {
  892.         move_icon_to(icon, desktop[icon].ob_x+diff_x, desktop[icon].ob_y+diff_y);
  893.     }
  894. }
  895.  
  896. /***************************************************************************/
  897.  
  898. VOID get_icon_pos(WORD icon, WORD *x, WORD *y)
  899. {
  900.     if (icon==0)
  901.     {
  902.         *x = desktop[FKEYS].ob_x;
  903.         *y = desktop[FKEYS].ob_y;
  904.     }
  905.     else if (setin(used_icons,icon))
  906.     {
  907.         *x = desktop[icon].ob_x;
  908.         *y = desktop[icon].ob_y;
  909.     }
  910.     else
  911.     {
  912.         *x = -1;
  913.         *y = -1;
  914.     }
  915. }
  916.  
  917. VOID set_icon_name(WORD icon, UBYTE *name)
  918. {
  919.     CICONBLK    *ptr;
  920.  
  921.     if (!setin(used_icons,icon))
  922.     {
  923.         inote(1,FATALERR,8);
  924.         return;
  925.     }
  926.     ptr = (CICONBLK *)get_obspec(desktop, icon);
  927.     if (strlen(name) < 13)
  928.         strcpy(ptr->monoblk.ib_ptext, name);
  929.     else
  930.         strncpy(ptr->monoblk.ib_ptext, name, 12);
  931.     draw_winobject(get_window (0), icon);
  932. }
  933.  
  934. /***************************************************************************/
  935. /* Entfernen eines Icons vom Desktop                                                    */
  936. /***************************************************************************/
  937.  
  938. VOID del_icon_from_desk(WORD obj)
  939. {
  940.     RECT    ob;
  941.     WINDP window;
  942.  
  943.     if (!setin(used_icons,obj))
  944.     {
  945.         inote(1,FATALERR,7);
  946.         return;
  947.     }
  948.     window = get_window (0);
  949.     hide_objc(desktop, obj, TRUE);
  950.     select_objc(desktop,obj, FALSE);
  951.     setexcl(used_icons,obj);
  952.     if (sel_window==window)
  953.     {
  954.         setexcl(sel_objs, obj);
  955.         if (setcard(sel_objs)==0)
  956.  
  957.             sel_window = NULL;
  958.     }
  959.     if (!destruct)
  960.     {
  961.         objc_rect(desktop, obj, &ob, FALSE);
  962.         redraw_window(window, &ob);
  963.     }
  964. }
  965.  
  966. /***************************************************************************/
  967. /* Ändert ein Icons auf dem Desktop                                                        */
  968. /***************************************************************************/
  969.  
  970. VOID change_icon_on_desk(WORD obj, WORD icon)
  971. {
  972.     CICONBLK    *cicon1, *cicon2;
  973.     UBYTE        *str;
  974.  
  975.     if (is_icon_on_desk(obj))
  976.     {
  977.         cicon1 = (CICONBLK *)get_obspec(desktop, obj);
  978.         str = cicon1->monoblk.ib_ptext;
  979.         cicon2 = (CICONBLK *)get_obspec(icons, icon);
  980.         memcpy(cicon1, cicon2, sizeof(CICONBLK));
  981.         cicon1->monoblk.ib_ptext = str;
  982.  
  983.         desktop[obj].ob_width = icons[icon].ob_width;
  984.         desktop[obj].ob_height = icons[icon].ob_height;
  985.         draw_winobject(get_window (0), obj);
  986.     }
  987. }
  988.  
  989. /***************************************************************************/
  990. /* Aufräumen der Icons                                                                        */
  991. /***************************************************************************/
  992.  
  993. VOID clearup_desktop(VOID)
  994. {
  995.     WORD        i, diff_x, diff_y;
  996.     OBJECT    *object;
  997.  
  998.     if (!no_desktop)
  999.     {
  1000.         i = setmax(used_icons);
  1001.         for (object=&desktop[i]; i>=0; i--,object--)
  1002.             if (setin (used_icons, i) && i!=FKEYS)
  1003.             {
  1004.                 diff_x = (object->ob_x%ICON_RASTER_X);
  1005.                 diff_y = ((object->ob_y-desk.y)%ICON_RASTER_Y);
  1006.                 if ((diff_x+diff_x)>ICON_RASTER_X) diff_x -= ICON_RASTER_X;
  1007.                 if ((diff_y+diff_y)>ICON_RASTER_Y) diff_y -= ICON_RASTER_Y;
  1008.                 move_icon(i, -diff_x, -diff_y);
  1009.             }
  1010.     }
  1011. }
  1012.  
  1013. /***************************************************************************/
  1014. /* Desktop zeichnen                                                                             */
  1015. /***************************************************************************/
  1016. LOCAL VOID wi_draw(WINDP window, CONST RECT *r)
  1017. {
  1018.     RECT    r1;
  1019.  
  1020.     r1 = window->work;
  1021.     if (myrc_intersect(r, &r1))
  1022.         objc_draw (desktop, ROOT, MAX_DEPTH, r1.x, r1.y, r1.w, r1.h);
  1023. }
  1024.  
  1025. /***************************************************************************/
  1026. /* Selektieren des Fensterinhalts                                                        */
  1027. /***************************************************************************/
  1028.  
  1029. LOCAL VOID wi_click (WINDP window, MKINFO *mk)
  1030. {
  1031.     RECT     *s = &window->work;
  1032.     WORD     obj, result, mobutton;
  1033.     SET     new_obj;
  1034.  
  1035.     if (mk->mobutton & 2)                    /* Rechtsclick */
  1036.         return;
  1037.  
  1038.     if (!inside(mk->mox,mk->moy,s))
  1039.         return;
  1040.  
  1041.     obj = objc_find (desktop, ROOT, 2, mk->mox, mk->moy); /* Nur 2 Ebenen */
  1042.     if (obj >= IF1 && obj <= IF10)                                /* Funktionstaste */
  1043.     {
  1044.         mk->scan_code  = 0x3B00 + (obj - IF1) * 0x100;
  1045.         mk->ascii_code = 0;
  1046.  
  1047.         graf_mkstate (&result, &result, &mobutton, &result);
  1048.         if (mobutton&1)                                /* Immernoch gedrückt ?    */
  1049.             evnt_button(1, 1, 0, &result, &result, &result, &result);
  1050.         key_window (window, mk);
  1051.     }
  1052.     else if (obj >= IFS1 && obj <= IFS10)                            /* Shift+Funktionstaste */
  1053.     {
  1054.         mk->scan_code  = 0x5400 + (obj - IFS1) * 0x100;
  1055.         mk->ascii_code = 0;
  1056.         mk->shift = TRUE;
  1057.  
  1058.         graf_mkstate (&result, &result, &mobutton, &result);
  1059.         if (mobutton & 1)                                /* Immernoch gedrückt ?    */
  1060.             evnt_button(1, 1, 0, &result, &result, &result, &result);
  1061.         key_window (window, mk);
  1062.     }
  1063.     else
  1064.     {
  1065.         if (objc_find (desktop, ROOT, 1, mk->mox, mk->moy)==FKEYS)
  1066.             obj = FKEYS;
  1067.  
  1068.         if (sel_window != window || obj == FKEYS)
  1069.             unclick_window ();                                         /* Deselektieren */
  1070.         if (obj == NIL)
  1071.             return;
  1072.  
  1073.         if (get_obtype(desktop, obj, NULL) == G_CICON)
  1074.         {
  1075.             if (!in_icon (mk->mox, mk->moy, desktop, obj))
  1076.                 obj = ROOT;
  1077.         }
  1078.  
  1079.         if (get_obtype(desktop, obj, NULL) == G_CICON || obj==FKEYS)
  1080.         {
  1081.             setclr (new_obj);
  1082.             setincl (new_obj, obj);                                    /* Aktuelles Objekt */
  1083.             if (mk->breturn>1 && obj!=FKEYS)                        /* Doppelklick */
  1084.             {
  1085.                 if (sel_window==window)
  1086.                     unclick_window ();
  1087.                 select_objs (window, new_obj);
  1088.                 sel_window = window;
  1089.                 setcpy(sel_objs,new_obj);
  1090.                 graf_mkstate (&result, &result, &mobutton, &result);
  1091.                 if (mobutton&1)                                        /* Immernoch gedrückt ?    */
  1092.                     evnt_button(1, 1, 0, &result, &result, &result, &result);
  1093.                 if (do_icon(obj,DO_OPEN)<0)
  1094.                     note(1, NOWINDOW);
  1095.             }
  1096.             else                                                            /* Einfachklick */
  1097.             {
  1098.                 if (mk->kstate & (K_RSHIFT|K_LSHIFT))            /* xor Auswahl */
  1099.                 {
  1100.                     invert_objs (window, new_obj);
  1101.                     setxor (sel_objs, new_obj);
  1102.                     if (!setin (sel_objs, obj)) obj = NIL;     /* Wieder deselektiert */
  1103.                 }
  1104.                 else if (!setin (sel_objs, obj))                    /* Neues Objekt */
  1105.                 {
  1106.                     if (sel_window==window)
  1107.                         unclick_window ();                            /* Alte Objekte löschen */
  1108.                     select_objs (window, new_obj);                /* Neues setzten */
  1109.                     setcpy(sel_objs,new_obj);
  1110.                 }
  1111.                 sel_window = (setcard(sel_objs)==0)?NULL:window;
  1112.                 if (obj!=NIL)
  1113.                     drag_objs (window, sel_objs, mk->mox, mk->moy);
  1114.                 else
  1115.                     evnt_button(1, 1, 0, &result, &result, &result, &result);
  1116.             }
  1117.         }
  1118.         else    /* auf Hintergrund geklickt */
  1119.         {
  1120.             if (!(mk->shift))
  1121.                 unclick_window ();                                /* Deselektieren */
  1122.             if (mk->breturn == 1 && mk->mobutton & 1)
  1123.                 rubber_objs (window,mk);                        /* Gummiband-Operation */
  1124.             else
  1125.             {
  1126.                 wind_update (BEG_MCTRL);                                /* Mauskontrolle übernehmen */
  1127.                 evnt_button(1, 1, 0, &result, &result, &result, &result);
  1128.                 wind_update (END_MCTRL);                                /* Mauskontrolle übernehmen */
  1129.             }
  1130.         }
  1131.     }
  1132. } /* wi_click */
  1133.  
  1134. /***************************************************************************/
  1135.  
  1136. LOCAL VOID wi_unclick (WINDP window)
  1137. {
  1138.     clear_objs (window, sel_objs);
  1139. }
  1140.  
  1141. /***************************************************************************/
  1142. /* Taste für Fenster                                                                            */
  1143. /***************************************************************************/
  1144.  
  1145. LOCAL BOOLEAN wi_key (WINDP window, MKINFO *mk)
  1146. {
  1147.     if (mk->kreturn == (NKF_FUNC|NK_HELP))
  1148.     {
  1149.         do_action(DO_HELP);
  1150.         return TRUE;
  1151.     }
  1152.     if (mk->kreturn == (NKF_FUNC|NK_INS))
  1153.     {
  1154.         set_overwrite(!overwrite);
  1155.         return TRUE;
  1156.     }
  1157.     else if ((mk->kreturn & NKF_ALT) && (mk->scan_code >= 0x3B00  && mk->scan_code <= 0x4400))
  1158.     /* Alt+Funktionstasten => Programmende mit Returncode */
  1159.     {
  1160.         return_code = ((mk->scan_code - 0x3B00) / 0x100) + 1;
  1161.         quick_close = TRUE;
  1162.         if (do_icon(0,DO_DESTRUCT)<=0)
  1163.             return_code = 0;
  1164.         return (TRUE);
  1165.     }
  1166.     else if ((mk->scan_code >= 0x3B00 && mk->scan_code <= 0x4400) ||
  1167.                 (mk->scan_code >= 0x5400 && mk->scan_code <= 0x5D00))
  1168.     {
  1169.         if (!start_play (mk->scan_code, 1))    /* Makro abspielen */
  1170.             send_avkey(mk->kstate, mk->scan_code);
  1171.     }
  1172.     return (menu_key(mk));
  1173. } /* wi_key */
  1174.  
  1175. /***************************************************************************/
  1176. /* Kreieren eines Fensters                                                                    */
  1177. /***************************************************************************/
  1178.  
  1179. LOCAL VOID    crt_desktop (WORD icon, WINDP window)
  1180. {
  1181.     WORD        menu_height;
  1182.  
  1183.     menu_height = 0;
  1184.     window->flags = FLAGS|WI_MAIN_MENU;
  1185.  
  1186.     if (no_desktop)
  1187.     {
  1188.         window->work.x = INITX - odd (desk.x);
  1189.         window->work.y = (INITY - odd (desk.y)) - menu_height;
  1190.         window->work.w = INITW;
  1191.         window->work.h = menu_height;
  1192.     }
  1193.     else
  1194.     {
  1195.         window->doc.w        = desk.w / XFAC;
  1196.         window->doc.h        = desk.h / YFAC;
  1197.         window->xfac        = XFAC;
  1198.         window->yfac        = YFAC;
  1199.         window->work        = desk;
  1200.         window->w_width    = window->work.w / XFAC;
  1201.         window->w_hight    = window->work.h / YFAC;
  1202.     }
  1203.     if (!no_desktop)
  1204.     {
  1205.         window->click        = wi_click;
  1206.         window->unclick    = wi_unclick;            /* Icons deselektieren */
  1207.     }
  1208.     window->key            = wi_key;
  1209.     window->draw        = wi_draw;
  1210.  
  1211.     set_wname(window,"qed - Desktop");
  1212. } /* crt_desktop */
  1213.  
  1214. /***************************************************************************/
  1215. /* Öffnen des Objekts                                                                        */
  1216. /***************************************************************************/
  1217.  
  1218. LOCAL BOOLEAN open_desktop ()
  1219. {
  1220.     BOOLEAN    ok;
  1221.     WINDP    window;
  1222.  
  1223.     window = get_window (0);                    /* Suche Desktop */
  1224.     if (window!=NULL)
  1225.     {
  1226.         ok = TRUE;
  1227.         if (!window->opened)
  1228.             ok = open_window (window);            /* Desktop öffnen */
  1229.         else
  1230.             top_window (window);                    /* Bringe Desktop nach oben */
  1231.     }
  1232.     else
  1233.         ok = FALSE;
  1234.     return (ok);
  1235. } /* open_desktop */
  1236.  
  1237. /***************************************************************************/
  1238.  
  1239. VOID clearup_dial(VOID)
  1240. {
  1241.     WORD    antw, i;
  1242.     UBYTE s[10];
  1243.  
  1244.     select_objc(clearup, CUWIN, cu_window);
  1245.     disable_objc(clearup, CUICON, no_desktop);
  1246.     select_objc(clearup, CUICON, cu_icon);
  1247.  
  1248.     select_objc(clearup, CU1, cu_mode==0);
  1249.     select_objc(clearup, CU2, cu_mode==1);
  1250.     select_objc(clearup, CU3, cu_mode==2);
  1251.  
  1252.     select_objc(clearup, CUWIDTH, cu_width);
  1253.     itoa(cu_width2,s,10);
  1254.     objc_setstring(clearup, CUWIDTH2, s);
  1255.     select_objc(clearup, CUHIGH, cu_high);
  1256.     itoa(cu_high2,s,10);
  1257.     objc_setstring(clearup, CUHIGH2, s);
  1258.  
  1259.     Arrow_mouse();
  1260.     antw = HndlDial(clearup, 0, FALSE, NULL, NULL);
  1261.     Last_mouse();
  1262.     if (antw == CUOK)
  1263.     {
  1264.         cu_window = get_select(clearup,CUWIN);
  1265.         cu_icon = get_select(clearup,CUICON);
  1266.         cu_width = get_select(clearup,CUWIDTH);
  1267.  
  1268.         cu_high = get_select(clearup,CUHIGH);
  1269.         objc_getstring(clearup, CUWIDTH2, s);
  1270.         cu_width2 = atoi(s);
  1271.         objc_getstring(clearup, CUHIGH2, s);
  1272.         cu_high2 = atoi(s);
  1273.         for (i=0; i<3; i++)
  1274.             if (get_select(clearup,CU1+i))
  1275.             {
  1276.                 cu_mode = i;
  1277.                 break;
  1278.             }
  1279.         if (cu_window)
  1280.             clearup_windows(cu_mode, cu_width?cu_width2:0, cu_high?cu_high2:0);
  1281.         if (cu_icon)
  1282.             clearup_desktop();
  1283.     }
  1284. }
  1285.  
  1286. /***************************************************************************/
  1287.  
  1288. VOID info_desktop (VOID)
  1289. {
  1290.     WORD    antw;
  1291.  
  1292.     objc_setstring(about, ADATUM, __DATE__);
  1293.     objc_setstring(about, AVERSION, ProgrammVersion);
  1294.     Arrow_mouse();
  1295.     antw = HndlDial(about, 0, FALSE, NULL, NULL);
  1296.     if (antw == AINFO)
  1297.         HndlDial(about2, 0, FALSE, NULL, NULL);
  1298.     Last_mouse();
  1299. }
  1300.  
  1301. VOID init_desktop (VOID)
  1302. {
  1303.     WORD    i, desk_type;
  1304.  
  1305.     setclr(used_icons);
  1306.     for (i=20; (--i)>=0; )
  1307.         objc_setstring (desktop, IF1+i, "");
  1308.     desk_type = decl_icon_type(icon_test,icon_edit,icon_exist,(BOOLEAN(*)(WORD,WORD))NULL);
  1309.     add_icon(desk_type, 0);
  1310. }
  1311.  
  1312. BOOLEAN init2_desktop(VOID)
  1313. {
  1314.     BOOLEAN    erg;
  1315.  
  1316.     erg = (create_window(0, DESK, 0, crt_desktop)!=NULL);
  1317.     return erg;
  1318. }
  1319.